home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / zutil.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  22KB  |  998 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. */
  5. #ifndef lint
  6. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/zutil.c,v 1.6 92/03/26 18:27:16 jonathan Exp $";
  7. #endif
  8.  
  9. /* Change log:
  10.  * $Log:    zutil.c,v $
  11.  * Revision 1.6  92/03/26  18:27:16  jonathan
  12.  * Fixed function declaration.
  13.  * 
  14.  * Revision 1.5  92/03/07  19:41:14  jonathan
  15.  * ANSIfied argument list.
  16.  * 
  17.  * Revision 1.4  92/02/12  14:01:37  jonathan
  18.  * Added "$Log" so RCS will put the log message in the header
  19.  * 
  20.  *
  21.    3.26.90    Harry Morris, morris@think.com
  22.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  23.    4.11.90  HWM - fixed include file names, changed 
  24.                    - writeCompressedIntegerWithPadding() to
  25.                   writeCompressedIntWithPadding()
  26.                 - generalized conditional includes (see c-dialect.h)
  27.    3.7.91   Jonny Goldman.  Replaced "short" in makeBitMap with "int" line 632.
  28. */
  29.  
  30. #define _C_utils_Z39_50_
  31.  
  32. #include "zutil.h"
  33.  
  34. #include <math.h>
  35. #include <string.h>
  36.  
  37. char* readErrorPosition = NULL; /* pos where buf stoped making sense */
  38.  
  39. /*----------------------------------------------------------------------*/
  40. /* A note on error handling 
  41.    read - these are low level routines, they do not check the type tags
  42.    which (sometimes) preceed the data (this is done by the higher
  43.    level functions which call these functions).  There is no 
  44.    attempt made to check that the reading does not exceed the read
  45.    buffer.  Such cases should be very rare and usually will be 
  46.    caught by the calling functions. (note - it is unlikely that 
  47.    a series of low level reads will go far off the edge without
  48.    triggering a type error.  However, it is possible for a single
  49.    bad read in an array function (eg. readAny) to attempt to read a 
  50.    large ammount, possibly causing a segmentation violation or out
  51.    of memory condition.
  52.  */
  53. /*----------------------------------------------------------------------*/
  54.  
  55. diagnosticRecord* 
  56. makeDiag(surrogate,code,addInfo)
  57. boolean surrogate;
  58. char* code;
  59. char* addInfo;
  60. {
  61.   diagnosticRecord* diag = 
  62.     (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  63.   
  64.   diag->SURROGATE = surrogate;
  65.   memcpy(diag->DIAG,code,DIAGNOSTIC_CODE_SIZE);
  66.   diag->ADDINFO = s_strdup(addInfo); 
  67.  
  68.   return(diag);
  69. }
  70.  
  71. /*----------------------------------------------------------------------*/
  72.  
  73. void 
  74. freeDiag(diag)
  75. diagnosticRecord* diag;
  76. { 
  77.   if (diag != NULL)
  78.     { if (diag->ADDINFO != NULL)
  79.     s_free(diag->ADDINFO);
  80.     s_free(diag);
  81.       }
  82. }
  83.  
  84. /*----------------------------------------------------------------------*/
  85.  
  86. #define END_OF_RECORD    0x1D
  87.  
  88. char* 
  89. writeDiag(diag,buffer,len)
  90. diagnosticRecord* diag;
  91. char* buffer;
  92. long* len;
  93. /* diagnostics (as per Appendix D) have a very weird format - this changes
  94.    in SR-1
  95.  */
  96. {
  97.   char* buf = buffer;
  98.   long  length;
  99.   
  100.   if (diag == NULL)        /* handle unspecified optional args */
  101.     return(buf);
  102.  
  103.   buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len);
  104.   CHECK_FOR_SPACE_LEFT(0L,len);
  105.   
  106.   length = 3; 
  107.   if (diag->ADDINFO != NULL)
  108.     length += strlen(diag->ADDINFO);
  109.     
  110.   if (length >= 0xFFFF )    /* make sure the length is reasonable */
  111.     { length = 0xFFFF - 1;
  112.       diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
  113.     }
  114.    
  115.   buf = writeBinaryInteger(length,2L,buf,len);
  116.  
  117.   CHECK_FOR_SPACE_LEFT(1L,len);
  118.   buf[0] = diag->DIAG[0]; 
  119.   buf++;
  120.   
  121.   CHECK_FOR_SPACE_LEFT(1L,len);
  122.   buf[0] = diag->DIAG[1];
  123.   buf++;
  124.   
  125.   if (length > 3)
  126.     { CHECK_FOR_SPACE_LEFT(3L,len);
  127.       memcpy(buf,diag->ADDINFO,(size_t)length - 3);
  128.       buf += length - 3;
  129.     }
  130.    
  131.   CHECK_FOR_SPACE_LEFT(1L,len);
  132.   buf[0] = diag->SURROGATE;
  133.   buf++;
  134.   
  135.   CHECK_FOR_SPACE_LEFT(1L,len);
  136.   buf[0] = END_OF_RECORD;
  137.   buf++;
  138.  
  139.   return(buf);
  140. }
  141.  
  142. /*----------------------------------------------------------------------*/
  143.  
  144. char* 
  145. readDiag(diag,buffer)
  146. diagnosticRecord** diag;
  147. char* buffer;
  148. {
  149.   char* buf = buffer;
  150.   diagnosticRecord* d 
  151.     = (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  152.   data_tag tag;
  153.   long len;
  154.   
  155.   buf = readTag(&tag,buf);
  156.   
  157.   buf = readBinaryInteger(&len,2L,buf);
  158.   
  159.   d->DIAG[0] = buf[0];
  160.   d->DIAG[1] = buf[1];
  161.   d->DIAG[2] = '\0';
  162.     
  163.   if (len > 3)
  164.     { d->ADDINFO = (char*)s_malloc((size_t)(len - 3 + 1));
  165.       memcpy(d->ADDINFO,(char*)(buf + 2),(size_t)(len - 3));
  166.       d->ADDINFO[len - 3] = '\0';
  167.     }
  168.   else
  169.     d->ADDINFO = NULL;
  170.     
  171.   d->SURROGATE = buf[len - 1];
  172.   
  173.   *diag = d;
  174.  
  175.   return(buf + len + 1);
  176. }
  177.  
  178. /*----------------------------------------------------------------------*/
  179.  
  180. #define continueBit    0x80
  181. #define dataMask    0x7F
  182. #define dataBits    7
  183.  
  184. char*
  185. writeCompressedInteger(num,buf,len)
  186. unsigned long num;
  187. char* buf;
  188. long* len;
  189. /* write a binary integer in the format described on p. 40.
  190.    this might be sped up 
  191. */
  192. {
  193.   char byte;
  194.   long i;
  195.   unsigned long size;
  196.   
  197.   size = writtenCompressedIntSize(num);
  198.   CHECK_FOR_SPACE_LEFT(size,len);
  199.   
  200.   for (i = size - 1; i >= 0; i--)
  201.     { byte = num & dataMask;
  202.       if (i != (size-1))    /* turn on continue bit */
  203.     byte = (char)(byte | continueBit);
  204.       buf[i] = byte;
  205.       num = num >> dataBits;    /* don't and here */
  206.     }
  207.    
  208.   return(buf + size);
  209. } 
  210.  
  211. /*----------------------------------------------------------------------*/
  212.  
  213. char*
  214. readCompressedInteger(num,buf)
  215. unsigned long *num;
  216. char* buf;
  217. /* read a binary integer in the format described on p. 40.
  218.    this might be sped up 
  219. */
  220. {
  221.   long i = 0;
  222.   unsigned char byte;
  223.  
  224.   *num = 0;
  225.   
  226.   do 
  227.     { byte = buf[i++];
  228.       *num = *num << dataBits;
  229.       *num += (byte & dataMask);
  230.     }
  231.   while (byte & continueBit);
  232.  
  233.   return(buf + i);
  234. } 
  235.  
  236. /*----------------------------------------------------------------------*/
  237.  
  238. #define pad    128 /* high bit is set */
  239.  
  240. char*
  241. writeCompressedIntWithPadding(num,size,buffer,len)
  242. unsigned long num;
  243. unsigned long size;
  244. char* buffer;
  245. long* len;
  246. /* Like writeCompressedInteger, except writes padding (128) to make
  247.    sure that size bytes are used.  This can be read correctly by 
  248.    readCompressedInteger()
  249. */
  250. {
  251.   char* buf = buffer;
  252.   unsigned long needed,padding;
  253.   long i;
  254.     
  255.   CHECK_FOR_SPACE_LEFT(size,len);
  256.   
  257.   needed = writtenCompressedIntSize(num);
  258.   padding = size - needed;
  259.   i = padding - 1;
  260.  
  261.   for (i = padding - 1;i >= 0;i--)
  262.     { buf[i] = pad;
  263.     }
  264.   
  265.   buf = writeCompressedInteger(num,buf + padding,len);
  266.   
  267.   return(buf);
  268. } 
  269.  
  270. /*----------------------------------------------------------------------*/
  271.  
  272. unsigned long
  273. writtenCompressedIntSize(num)
  274. unsigned long num;
  275. /* return the number of bytes needed to represnet the value num in
  276.    compressed format.  curently limited to 4 bytes
  277.  */
  278. {
  279.   if (num < CompressedInt1Byte) 
  280.     return(1);
  281.   else if (num < CompressedInt2Byte) 
  282.     return(2);
  283.   else if (num < CompressedInt3Byte)
  284.     return(3);
  285.   else
  286.     return(4);    
  287. }
  288.  
  289. /*----------------------------------------------------------------------*/
  290.  
  291. char*
  292. writeTag(tag,buf,len)
  293. data_tag tag;
  294. char* buf;
  295. long* len;
  296. /* write out a data tag */
  297. { 
  298.   return(writeCompressedInteger(tag,buf,len));
  299. } 
  300.  
  301. /*----------------------------------------------------------------------*/
  302.  
  303. char*
  304. readTag(tag,buf)
  305. data_tag* tag;
  306. char* buf;
  307. /* read a data tag */
  308. { 
  309.   return(readCompressedInteger(tag,buf));
  310. } 
  311.  
  312. /*----------------------------------------------------------------------*/
  313.  
  314. unsigned long 
  315. writtenTagSize(tag)
  316. data_tag tag;
  317. { 
  318.   return(writtenCompressedIntSize(tag));
  319. }
  320.  
  321. /*----------------------------------------------------------------------*/
  322.  
  323. data_tag
  324. peekTag(buf)
  325. char* buf;
  326. /* read a data tag without advancing the buffer */
  327. {
  328.   data_tag tag;
  329.   readTag(&tag,buf);
  330.   return(tag);
  331. } 
  332.  
  333. /*----------------------------------------------------------------------*/
  334.  
  335. any* 
  336. makeAny(size,data)
  337. unsigned long size;
  338. char* data;
  339. {
  340.   any* a = (any*)s_malloc((size_t)sizeof(any));
  341.   a->size = size;
  342.   a->bytes = data;
  343.   return(a);
  344. }
  345.  
  346. /*----------------------------------------------------------------------*/
  347.  
  348. void
  349. freeAny(a)
  350. any* a;
  351. /* destroy an any and its associated data. Assumes a->bytes was
  352.    allocated using the s_malloc family of libraries 
  353.  */
  354. {
  355.   if (a != NULL)
  356.     { if (a->bytes != NULL)
  357.     s_free(a->bytes);
  358.       s_free(a);
  359.     }
  360. }
  361.  
  362. /*----------------------------------------------------------------------*/
  363.  
  364. any* 
  365. duplicateAny(a)
  366. any* a;
  367. {
  368.   any* copy = NULL;
  369.  
  370.   if (a == NULL)
  371.     return(NULL);
  372.  
  373.   copy = (any*)s_malloc((size_t)sizeof(any));
  374.   copy->size = a->size;
  375.   if (a->bytes == NULL)
  376.     copy->bytes = NULL;
  377.   else
  378.     { copy->bytes = (char*)s_malloc((size_t)copy->size);
  379.       memcpy(copy->bytes,a->bytes,(size_t)copy->size);
  380.     }
  381.   return(copy);
  382. }
  383.  
  384. /*----------------------------------------------------------------------*/
  385.  
  386. char* 
  387. writeAny(a,tag,buffer,len)
  388. any* a;
  389. data_tag tag;
  390. char* buffer;
  391. long* len;
  392. /* write an any + tag and size info */
  393. {
  394.   char* buf = buffer;
  395.  
  396.   if (a == NULL)        /* handle unspecified optional args */
  397.     return(buf);
  398.   
  399.   /* write the tags */
  400.   buf = writeTag(tag,buf,len);
  401.   buf = writeCompressedInteger(a->size,buf,len);
  402.  
  403.   /* write the bytes */
  404.   CHECK_FOR_SPACE_LEFT(a->size,len);
  405.   memcpy(buf,a->bytes,(size_t)a->size);
  406.  
  407.   return(buf+a->size);
  408. }
  409.  
  410. /*----------------------------------------------------------------------*/
  411.  
  412. char* 
  413. readAny(anAny,buffer)
  414. any** anAny;
  415. char* buffer;
  416. /* read an any + tag and size info */
  417. {
  418.   char* buf = buffer;
  419.   any* a = (any*)s_malloc((size_t)sizeof(any));
  420.   data_tag tag;
  421.   
  422.   buf = readTag(&tag,buf);
  423.   buf = readCompressedInteger(&a->size,buf);
  424.   /* now simply copy the bytes */
  425.   a->bytes = (char*)s_malloc((size_t)a->size);
  426.   memcpy(a->bytes,buf,(size_t)a->size);
  427.   *anAny = a;
  428.   return(buf+a->size);
  429. }
  430.  
  431. /*----------------------------------------------------------------------*/
  432.  
  433. unsigned long 
  434. writtenAnySize(tag,a)
  435. data_tag tag;
  436. any* a;
  437. {
  438.   unsigned long size;
  439.  
  440.   if (a == NULL)
  441.     return(0);
  442.  
  443.   size = writtenTagSize(tag);
  444.   size += writtenCompressedIntSize(a->size);
  445.   size += a->size;
  446.   return(size);
  447. }
  448.  
  449. /*----------------------------------------------------------------------*/
  450.  
  451. any*
  452. stringToAny(s)
  453. char* s;
  454. {
  455.   any* a = NULL;
  456.   
  457.   if (s == NULL)
  458.     return(NULL);
  459.     
  460.   a = (any*)s_malloc((size_t)sizeof(any));
  461.   a->size = strlen(s);
  462.   a->bytes = (char*)s_malloc((size_t)a->size);
  463.   memcpy(a->bytes,s,(size_t)a->size);
  464.   return(a);
  465. }
  466.  
  467. /*----------------------------------------------------------------------*/
  468.  
  469. char*
  470. anyToString(a)
  471. any* a;
  472. {
  473.   char* s = NULL;
  474.   
  475.   if (a == NULL)
  476.     return(NULL);
  477.     
  478.   s = s_malloc((size_t)(a->size + 1));
  479.   memcpy(s,a->bytes,(size_t)a->size);
  480.   s[a->size] = '\0';
  481.   return(s);
  482. }
  483.  
  484. /*----------------------------------------------------------------------*/
  485.  
  486. char* 
  487. writeString(s,tag,buffer,len)
  488. char* s;
  489. data_tag tag;
  490. char* buffer;
  491. long* len;
  492. /* Write a C style string.  The terminating null is not written. 
  493.    This function is not part of the Z39.50 spec.  It is provided
  494.    for the convienience of those wishing to pass C strings in 
  495.    the place of an any.
  496.  */
  497. {
  498.   char* buf = buffer;
  499.   any* data = NULL;
  500.   if (s == NULL)
  501.     return(buffer);        /* handle unused optional item before making an any */
  502.   data = (any*)s_malloc((size_t)sizeof(any)); 
  503.   data->size = strlen(s);
  504.   data->bytes = s;        /* save a copy here by not using stringToAny() */
  505.   buf = writeAny(data,tag,buf,len);
  506.   s_free(data);            /* don't use freeAny() since it will free s too */
  507.   return(buf);
  508. }
  509.  
  510. /*----------------------------------------------------------------------*/
  511.  
  512. char* 
  513. readString(s ,buffer)
  514. char** s ;
  515. char* buffer;
  516. /* Read an any and convert it into a C style string.
  517.    This function is not part of the Z39.50 spec.  It is provided
  518.    for the convienience of those wishing to pass C strings in 
  519.    the place of an any. 
  520.  */
  521. {
  522.   any* data = NULL;
  523.   char* buf = readAny(&data,buffer);
  524.   *s = anyToString(data);
  525.   freeAny(data);
  526.   return(buf);
  527. }
  528.  
  529. /*----------------------------------------------------------------------*/
  530.  
  531. unsigned long 
  532. writtenStringSize(tag,s)
  533. data_tag tag;
  534. char* s;
  535. {
  536.   unsigned long size;
  537.  
  538.   if (s == NULL)
  539.    return(0);
  540.  
  541.   size = writtenTagSize(tag);
  542.   size += writtenCompressedIntSize(size);
  543.   size += strlen(s);
  544.   return(size);
  545. }
  546.  
  547. /*----------------------------------------------------------------------*/
  548.  
  549. any* 
  550. longToAny(num)
  551. long num;
  552. /* a convienience function */
  553. {
  554.   char s[40];
  555.  
  556.   sprintf(s,"%ld",num);
  557.   
  558.   return(stringToAny(s));
  559. }
  560.  
  561. /*----------------------------------------------------------------------*/
  562.  
  563. long
  564. anyToLong(a)
  565. any* a;
  566. /* a convienience function */
  567. {
  568.   long num;
  569.   char* str = NULL;
  570.   str = anyToString(a);
  571.   sscanf(str,"%ld",&num);    /* could check the result and return
  572.                    an error */
  573.   s_free(str);
  574.   return(num);
  575. }
  576.  
  577. /*----------------------------------------------------------------------*/
  578.  
  579. #define bitsPerByte    8
  580.  
  581. #ifdef ANSI_LIKE /* use ansi */
  582.  
  583. bit_map*
  584. makeBitMap(unsigned long numBits,...)
  585. /* construct and return a bitmap with numBits elements */
  586. {
  587.   va_list ap;
  588.   long i,j;
  589.   bit_map* bm = NULL;
  590.  
  591.   va_start(ap,numBits);
  592.   
  593.   bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  594.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte); 
  595.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  596.   
  597.   /* fill up the bits */
  598.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  599.     { char byte = 0;
  600.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  601.     { if ((i * bitsPerByte + j) < numBits)
  602.         { boolean bit = false;
  603.           bit = (boolean)va_arg(ap,boolean); 
  604.           if (bit)
  605.             { byte = byte | (1 << (bitsPerByte - j - 1));
  606.             }
  607.         }
  608.       }
  609.       bm->bytes[i] = byte;
  610.     }
  611.  
  612.   va_end(ap);
  613.   return(bm);
  614. }
  615.  
  616. #else /* use K & R */
  617.  
  618. bit_map*
  619. makeBitMap(va_alist)
  620. va_dcl
  621. /* construct and return a bitmap with numBits elements */
  622. {
  623.   va_list ap;
  624.   long i,j;
  625.   unsigned long numBits;
  626.   bit_map* bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  627.  
  628.   va_start(ap);
  629.   
  630.   numBits = va_arg(ap,unsigned long);
  631.  
  632.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte);
  633.   
  634.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  635.   
  636.   /* fill up the bits */
  637.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  638.     { char byte = 0;
  639.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  640.     { if ((i * bitsPerByte + j) < numBits)
  641.         { boolean bit;
  642.           bit = (boolean)va_arg(ap,int); /* really boolean, but this 
  643.                         is how it is passed on stack */
  644.           if (bit)
  645.             { byte = byte | (1 << (bitsPerByte - j - 1));
  646.             }
  647.         }
  648.       }
  649.       bm->bytes[i] = byte;
  650.     }
  651.  
  652.   va_end(ap);
  653.  
  654.   return(bm);
  655. }
  656.  
  657. #endif 
  658.  
  659. /*----------------------------------------------------------------------*/
  660.  
  661. void
  662. freeBitMap(bm)
  663. bit_map* bm;
  664. /* destroy a bit map created by makeBitMap() */
  665. {
  666.   s_free(bm->bytes);
  667.   s_free(bm);
  668. }
  669.  
  670. /*----------------------------------------------------------------------*/
  671.  
  672. /* use this routine to interpret a bit map.  pos specifies the bit 
  673.    number.  bit 0 is the Leftmost bit of the first byte.  
  674.    Could do bounds checking.
  675.  */
  676.  
  677. boolean
  678. bitAtPos(pos,bm)
  679. long pos;
  680. bit_map* bm;
  681. {
  682.   if (pos > bm->size*bitsPerByte)
  683.     return false;
  684.   else
  685.     return((bm->bytes[(pos / bitsPerByte)] & 
  686.         (0x80>>(pos % bitsPerByte))) ?
  687.        true : false);
  688. }
  689.  
  690. /*----------------------------------------------------------------------*/
  691.  
  692. char*
  693. writeBitMap(bm,tag,buffer,len)
  694. bit_map* bm;
  695. data_tag tag;
  696. char* buffer;
  697. long* len;
  698. /* write a bitmap + type and size info */
  699. { 
  700.   return(writeAny((any*)bm,tag,buffer,len));
  701. }
  702.  
  703. /*----------------------------------------------------------------------*/
  704.  
  705. char*
  706. readBitMap(bm,buffer)
  707. bit_map** bm;
  708. char* buffer;
  709. /* read a bitmap + type and size info */
  710. { 
  711.   return(readAny((any**)bm,buffer));
  712. }
  713.  
  714. /*----------------------------------------------------------------------*/
  715.  
  716. char* 
  717. writeByte(byte,buf,len)
  718. unsigned long byte;
  719. char* buf;
  720. long* len;
  721. {
  722.   CHECK_FOR_SPACE_LEFT(1L,len);
  723.   buf[0] = byte & 0xFF; /* we really only want the first byte */
  724.   return(buf + 1);
  725. }
  726.  
  727. /*----------------------------------------------------------------------*/
  728.  
  729. char* 
  730. readByte(byte,buf)
  731. unsigned char* byte;
  732. char* buf;
  733. {
  734.   *byte = buf[0];
  735.   return(buf + 1);
  736. }
  737.  
  738. /*----------------------------------------------------------------------*/
  739.  
  740. char* 
  741. writeBoolean(flag,buf,len)
  742. boolean flag;
  743. char* buf;
  744. long* len;
  745. {
  746.   return(writeByte(flag,buf,len));
  747. }
  748.  
  749. /*----------------------------------------------------------------------*/
  750.  
  751. char* 
  752. readBoolean(flag,buffer)
  753. boolean* flag;
  754. char* buffer;
  755. {
  756.   unsigned char byte;
  757.   char* buf = readByte(&byte,buffer);
  758.   *flag = (byte == true) ? true : false;
  759.   return(buf);
  760. }
  761.  
  762. /*----------------------------------------------------------------------*/
  763.  
  764. char*
  765. writePDUType(pduType,buf,len)
  766. pdu_type pduType;
  767. char* buf;
  768. long* len;
  769. /* PDUType is a single byte */
  770. {
  771.   return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len));
  772. } 
  773.  
  774. /*----------------------------------------------------------------------*/
  775.  
  776. char*
  777. readPDUType(pduType,buf)
  778. pdu_type* pduType;
  779. char* buf;
  780. /* PDUType is a single byte */
  781. {
  782.   return(readBinaryInteger((long*)pduType,(unsigned long)1,buf));
  783. } 
  784.  
  785. /*----------------------------------------------------------------------*/
  786.  
  787. pdu_type
  788. peekPDUType(buf)
  789. char* buf;
  790. /* read the next pdu without advancing the buffer, Note that this 
  791.    function is to be used on a buffer that is known to contain an
  792.    APDU.  The pdu_type is written HEADER_LEN bytes into the buffer
  793.  */
  794. {
  795.   pdu_type pdu;
  796.   readPDUType(&pdu,buf + HEADER_LEN);
  797.   return(pdu);
  798. }
  799.  
  800. /*----------------------------------------------------------------------*/
  801.  
  802. #define BINARY_INTEGER_BYTES    sizeof(long) /* the number of bytes used by
  803.                         a "binary integer" */
  804. char*
  805. writeBinaryInteger(num,size,buf,len)
  806. long num;
  807. unsigned long size;
  808. char* buf;
  809. long* len;
  810. /* write out first size bytes of num - no type info
  811.   XXX should this take unsigned longs instead ???  */
  812. {
  813.   long i;
  814.   char byte;
  815.  
  816.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  817.     return(NULL);        /* error */
  818.  
  819.   CHECK_FOR_SPACE_LEFT(size,len);
  820.  
  821.   for (i = size - 1; i >= 0; i--)
  822.     { byte = (char)(num & 255);
  823.       buf[i] = byte;
  824.       num = num >> bitsPerByte; /* don't and here */
  825.     }
  826.  
  827.   return(buf + size);
  828. }
  829.  
  830. /*----------------------------------------------------------------------*/
  831.  
  832. char*
  833. readBinaryInteger(num,size,buf)
  834. long* num;
  835. unsigned long size;
  836. char* buf;
  837. /* read in first size bytes of num - no type info
  838.   XXX this should take unsigned longs instead !!! */
  839. {
  840.   long i;
  841.   unsigned char byte;
  842.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  843.     return(buf);        /* error */
  844.   *num = 0;
  845.   for (i = 0; i < size; i++)
  846.     { byte = buf[i];
  847.       *num = *num << bitsPerByte;
  848.       *num += byte;
  849.     }
  850.   return(buf + size);
  851. }
  852.  
  853. /*----------------------------------------------------------------------*/
  854.  
  855. unsigned long 
  856. writtenCompressedBinIntSize(num)
  857. long num;
  858. /* return the number of bytes needed to represent the value num.
  859.    currently limited to max of 4 bytes 
  860.    Only compresses for positive nums - negatives get whole 4 bytes
  861.  */
  862. {
  863.   if (num < 0L)
  864.     return(4);
  865.   else if (num < 256L)        /* 2**8 */
  866.     return(1);
  867.   else if (num < 65536L)    /* 2**16 */
  868.     return(2);
  869.   else if (num < 16777216L)    /* 2**24 */
  870.     return(3);
  871.   else
  872.     return(4);
  873. }
  874.  
  875. /*----------------------------------------------------------------------*/
  876.  
  877. char*
  878. writeNum(num,tag,buffer,len)
  879. long num;
  880. data_tag tag;
  881. char* buffer;
  882. long* len;
  883. /* write a binary integer + size and tag info */
  884. {
  885.   char* buf = buffer;
  886.   long size = writtenCompressedBinIntSize(num);
  887.   
  888.   if (num == UNUSED)
  889.     return(buffer);
  890.     
  891.   buf = writeTag(tag,buf,len);
  892.   buf = writeCompressedInteger(size,buf,len); 
  893.   buf = writeBinaryInteger(num,(unsigned long)size,buf,len); 
  894.   return(buf);
  895. }
  896.  
  897. /*----------------------------------------------------------------------*/
  898.  
  899. char*
  900. readNum(num,buffer)
  901. long* num;
  902. char* buffer;
  903. /* read a binary integer + size and tag info */
  904. {
  905.   char* buf = buffer;
  906.   data_tag tag;
  907.   unsigned long size;
  908.   unsigned long val;
  909.   
  910.   buf = readTag(&tag,buf);
  911.   buf = readCompressedInteger(&val,buf);
  912.   size = (unsigned long)val;
  913.   buf = readBinaryInteger(num,size,buf);
  914.   return(buf);
  915. }
  916.  
  917. /*----------------------------------------------------------------------*/
  918.  
  919. unsigned long 
  920. writtenNumSize(tag,num)
  921. data_tag tag;
  922. long num;
  923. {
  924.   long dataSize = writtenCompressedBinIntSize(num);
  925.   long size;
  926.   
  927.   size = writtenTagSize(tag); /* space for the tag */
  928.   size += writtenCompressedIntSize(dataSize); /* space for the size */
  929.   size += dataSize; /* space for the data */
  930.   
  931.   return(size);
  932. }
  933.  
  934. /*----------------------------------------------------------------------*/
  935.  
  936. typedef void (voidfunc)();
  937.  
  938. void
  939. doList(list,func)
  940. void** list;
  941. voidfunc *func;
  942. /* call func on each element of the NULL terminated list of pointers */
  943. {
  944.   register long i;
  945.   register void* ptr = NULL;
  946.   if (list == NULL)
  947.     return;
  948.   for (i = 0,ptr = list[i]; ptr != NULL; ptr = list[++i])
  949.     (*func)(ptr);
  950. }
  951.  
  952. /*----------------------------------------------------------------------*/
  953.  
  954. char* 
  955. writeProtocolVersion(buf,len)
  956. char* buf;
  957. long* len;
  958. /* write a bitmap describing the protocols available */
  959. {
  960.   static bit_map* version = NULL;
  961.  
  962.   if (version == NULL)
  963.    { version = makeBitMap((unsigned long)1,true); /* version 1! */
  964.    }
  965.     
  966.   return(writeBitMap(version,DT_ProtocolVersion,buf,len));
  967. }
  968.  
  969. /*----------------------------------------------------------------------*/
  970.  
  971. char*
  972. defaultImplementationID()
  973. {
  974.   static char    ImplementationID[] = "TMC";
  975.   return(ImplementationID);
  976. }
  977.  
  978. /*----------------------------------------------------------------------*/
  979.  
  980. char*
  981. defaultImplementationName()
  982. {
  983.   static char ImplementationName[] = "Thinking Machines Corporation Z39.50";
  984.   return(ImplementationName);
  985. }
  986.  
  987. /*----------------------------------------------------------------------*/
  988.  
  989. char*
  990. defaultImplementationVersion()
  991. {
  992.   static char    ImplementationVersion[] = "2.0A";
  993.   return(ImplementationVersion);
  994. }
  995.  
  996. /*----------------------------------------------------------------------*/
  997.  
  998.